Le document possédant l’extension “.Rmd” est au format markdown (comme wikipedia) et peut être annoté en tout temps.
N’hésitez pas à prendre vos notes directement dans ce document.
Computational Historical Thinking With Applications in R de Lincoln A. Mullen (incomplet)
http://dh-r.lincolnmullen.com/
Le syllabus de son cours.
http://lincolnmullen.com/courses/clio2.2018/
The Historian’s Macroscope: Big Digital History de Shawn Graham, Ian Milligan et Scott Weingart
http://www.themacroscope.org/?page_id=707
Le livre a été publié depuis, voir http://www.themacroscope.org/2.0/
Une ressource en français.
Introduction à R et au tidyverse de Julien Barnier
https://juba.github.io/tidyverse
R for Data Science de Garrett Grolemund & Hadley Wickham
An Introduction to Statistical and Data Sciences via R de Chester Ismay & Albert Y. Kim
Excel vs R: A Brief Introduction to R
https://www.jessesadler.com/post/excel-vs-r/
The Programming Historian
https://programminghistorian.org/
Les cheatsheets de RStudio
https://www.rstudio.com/resources/cheatsheets/
R est un langage de programmation à l’origine prévu pour faire de l’analyse statistique.
R est disponible sous licence libre. Il est basé sur le langage propriétaire S.
Son usage s’est répandu bien au-delà des statistiques.
Mais R désigne également une interface de programmation que l’on nomme R GUI, “GUI” signifiant “Graphical User Interface”.
R GUI est un logiciel libre.
RStudio est un environnement permettant de programmer en R, c’est-à-dire un peu plus qu’une simple interface graphique.
En plus d’afficher une console (là où le code est exécuté, généralement dans la fenêtre en bas à gauche) et une fenêtre de script (là où l’on rédige le code que l’on veut réutiliser, généralement en haut à gauche), RStudio permet par exemple de conserver bien en vue la liste des variables enregistrées en mémoire (en haut à droite), ou d’accéder aisément à des fichiers d’aide (en bas à droite).
RStudio permet également d’utiliser un notebook comme celui-ci.
… quand on connaît le nom de la fonction.
help(exp) ## La page d'aide d'une variable
?exp ## Une autre syntaxe pour le même résultat
La touche de tabulation est utile dans le cas où les premières lettres d’une fonction sont connues.
… quand on ne connaît pas le nom de la fonction mais seulement celui de la méthode.
help.search("linear model") ## Chercher dans les pages d'aide
??"linear model" ## Une autre syntaxe pour le même résultat
Dans ce notebook comme dans les scripts que vous trouverez en ligne, les fonctions peuvent sembler sortir d’un chapeau comme si de rien n’était.
Ne pas se faire d’illusions:
C’est pour cette raison qu’il ne faut jamais hésiter à faire une recherche
? lorsqu’on connaît la fonction.?? lorsqu’on ne la connaît pas.b (en anglais : “exponential”).a (en anglais : “square root”).La cheatsheet pour l’importation et l’exportation de données.
https://github.com/rstudio/cheatsheets/raw/master/data-import.pdf
Une fonction prédéfinie.
y = sqrt(4) ## Fonction racine carrée
y
[1] 2
Toutes les fonctions du package base.
help(package="base")
Une fonction construite pour l’occasion.
f <- function(x) {2*x}
f(17)
[1] 34
f(pi)
[1] 6.283185
Connaître la classe d’un objet.
z <- "hello"
class(z) ## Le type d'une variable
[1] "character"
La fonction str permet d’obtenir des informations plus complètes.
str(z)
chr "hello"
vec <- c(3,5,3,7)
str(vec)
num [1:4] 3 5 3 7
f <- function(x) {2*x}
str(f)
function (x)
- attr(*, "srcref")=Class 'srcref' atomic [1:8] 1 6 1 22 6 22 1 1
.. ..- attr(*, "srcfile")=Classes 'srcfilecopy', 'srcfile' <environment: 0x10f12cc78>
a <- f(17)
str(a)
num 34
Les chaînes de caractères sont des assemblages de symboles.
b <- "unil"
b
[1] "unil"
Il existe de nombreuses fonctions pour les manipuler.
Par exemple pour connaître leur longueur.
nchar(b)
[1] 4
Pour manipuler du texte de manière avancée dans R (ou dans n’importe quel autre langage de programmation), il peut être nécessaire d’apprendre à manipuler des expressions régulières.
Deux tutoriaux pour R.
La cheatsheet, indispensable.
https://github.com/rstudio/cheatsheets/raw/master/strings.pdf
Pour tester des expressions régulières :
Quelques ressources ludiques pour s’entraîner…
Mais aussi…
“NA” signifie “Not available”.
“NaN” signifie “Not a Number”.
1 == 1
[1] TRUE
1 == 2
[1] FALSE
1 != 1
[1] FALSE
1 != 2
[1] TRUE
1 < 1
[1] FALSE
1 <= 1
[1] TRUE
x <- c(5,4,5,6,7,8)
x
[1] 5 4 5 6 7 8
x_char = c("a","b","c")
x_char
[1] "a" "b" "c"
Accéder directement à un élément d’un vecteur
x
[1] 5 4 5 6 7 8
x[2]
[1] 4
x[c(2,4)]
[1] 4 6
x
[1] 5 4 5 6 7 8
x[c(-2,-4)]
[1] 5 5 7 8
Manipuler des vecteurs
x[6] = 10
x
[1] 5 4 5 6 7 10
a = c(3,4,5,6)
a[c(2,3)] = 0
a
[1] 3 0 0 6
a[c(2,3)] = c(8,7)
a
[1] 3 8 7 6
c(1,2,3) + c(3,4,5)
[1] 4 6 8
4 * c(1,2,3)
[1] 4 8 12
c(2,5) < 4
[1] TRUE FALSE
Attention lorsque deux éléments ne sont pas de même taille !
c(1,2) + c(3,4,5,6)
[1] 4 6 6 8
Attention lorsque l’un n’est pas multiple de l’autre !
c(1,2) + c(2,3,4)
longer object length is not a multiple of shorter object length
[1] 3 5 5
a <- 1
b <- 1:5
class(a)
[1] "numeric"
class(b)
[1] "integer"
c <- "hello"
d <- 1 > 2
class(c)
[1] "character"
class(d)
[1] "logical"
Quelle est la “taille” de l’objet ?
length(a)
[1] 1
length(b)
[1] 5
length(c)
[1] 1
length(d)
[1] 1
ls() ## Les variables sauvées dans l'environnement de travail
[1] "a" "aie" "b" "Best_contentStop" "Best_formStop"
[6] "c" "d" "dist" "f" "g"
[11] "i" "m1" "m2" "mp" "multiplot"
[16] "ouch" "p1" "p2" "p3" "p4"
[21] "retards" "tableau" "tablreau" "v1" "v2"
[26] "vec" "Worst_contentStop" "Worst_formStop" "x" "x_char"
[31] "y" "z"
rm(y) ## On retire la variable "y"
ls()
[1] "a" "aie" "b" "Best_contentStop" "Best_formStop"
[6] "c" "d" "dist" "f" "g"
[11] "i" "m1" "m2" "mp" "multiplot"
[16] "ouch" "p1" "p2" "p3" "p4"
[21] "retards" "tableau" "tablreau" "v1" "v2"
[26] "vec" "Worst_contentStop" "Worst_formStop" "x" "x_char"
[31] "z"
readrÀ partir de là, nous allons utiliser le package readr pour lire et écrire des informations textuelles.
Le code suivant vérifie si le package est installé sur votre machine et l’installe le cas échéant. Puis il le charge.
if (!require(readr)) install.packages("readr")
library(readr)
Pour l’exercice, nous allons utiliser un jeu de données avec une licence ouverte, trouvé sur le site data.gouv.fr
https://www.data.gouv.fr/fr/datasets/indices-mensuels-de-retard-des-bus/#_
Tout d’abord, il faut sauver le fichier dans le dossier de travail (“ENS-DH-R” dans notre cas).
Puis, pour l’importer, il ne faut pas oublier les guillemets autour du nom du fichier.
retards <- read_csv2("indices-mensuels-de-retard-des-bus.csv")
Using ',' as decimal and '.' as grouping mark. Use read_delim() for more control.
Parsed with column specification:
cols(
.default = col_number(),
Mois = col_character(),
`Citadine Halluin` = col_character(),
Z1 = col_character()
)
See spec(...) for full column specifications.
Il est important de lire les commentaires (souvent indiqués en rouge, comme les erreurs… malin).
Un aperçu de ce que nous avons importé.
retards
Un autre type d’aperçu.
str(retards)
Classes ‘tbl_df’, ‘tbl’ and 'data.frame': 11 obs. of 60 variables:
$ Mois : chr "08. Aout" "09. Septembre" "10. Octobre" "11. Novembre" ...
$ Citadine Tourcoing : num 106 109 102 109 104 141 126 92 94 141 ...
$ Citadine Roubaix : num 65 93 93 117 123 81 142 89 11 163 ...
$ Citadine Lille : num 91 148 95 109 83 76 95 78 73 66 ...
$ MWR : num 211 213 149 78 72 213 103 90 170 87 ...
$ COR : num 113 171 176 201 138 173 121 146 164 129 ...
$ Citadine Armentières: num 29 20 18 20 41 67 135 44 48 36 ...
$ Citadine Halluin : chr "1.0" "4.3" "6.8" "1.9" ...
$ L1 : num 121 162 120 119 106 158 104 98 110 97 ...
$ L2 : num 40 78 62 55 71 55 62 54 65 57 ...
$ L3 : num 96 121 50 64 43 87 48 58 54 65 ...
$ L4 : num 143 208 141 181 154 171 129 134 162 165 ...
$ L90 : num 51 64 60 66 56 99 42 48 64 56 ...
$ L91 : num 64 111 87 130 79 119 93 87 114 76 ...
$ Z1 : chr "0.8" "2.9" "1.8" "1.9" ...
$ Z2 : num 30 43 48 65 15 24 17 20 18 22 ...
$ Z3 : num 13 24 47 43 38 31 34 17 47 55 ...
$ Z4 : num 94 34 22 39 19 148 15 10 20 29 ...
$ 10 : num 89 106 114 134 109 123 105 118 108 115 ...
$ 11 : num 58 105 113 119 75 78 70 77 114 98 ...
$ 12 : num 137 218 206 157 129 181 120 136 169 122 ...
$ 13 : num 50 93 76 114 89 91 75 80 91 90 ...
$ 14 : num 193 232 208 222 147 243 156 143 141 127 ...
$ 15 : num 77 129 131 163 111 61 125 119 118 132 ...
$ 16 : num 95 139 146 162 119 91 110 91 131 157 ...
$ 17 : num 133 119 88 85 77 130 56 71 101 78 ...
$ 18 : num 167 195 193 190 177 139 131 153 176 200 ...
$ 30 : num 115 167 132 142 100 107 109 81 122 106 ...
$ 32 : num 84 98 94 89 101 149 76 84 99 92 ...
$ 33 : num 58 110 105 106 146 71 86 89 94 123 ...
$ 35 : num 56 148 128 126 118 91 139 99 131 124 ...
$ 36 : num 62 66 46 57 40 70 46 50 48 68 ...
$ 37 : num 125 153 76 71 71 116 61 76 74 77 ...
$ 50 : num 72 101 122 153 94 106 77 94 91 91 ...
$ 51 : num 43 41 50 45 33 33 43 37 32 34 ...
$ 52 : num 42 79 130 114 67 69 84 76 70 71 ...
$ 53 : num 99 126 85 93 72 89 97 61 93 89 ...
$ 54 : num 118 117 100 140 83 108 87 67 98 88 ...
$ 55 : num 95 115 130 155 98 112 99 93 102 94 ...
$ 57 : num 80 129 101 132 126 93 94 91 126 104 ...
$ 58 : num 73 156 116 117 92 85 96 78 86 114 ...
$ 59 : num 26 47 50 62 38 37 37 45 40 55 ...
$ 56 : num 33 66 76 108 74 88 101 83 71 77 ...
$ 61 : num 54 57 77 95 24 54 55 27 34 66 ...
$ 63 : num 60 67 113 85 53 99 97 70 51 63 ...
$ 64 : num 93 63 68 70 43 112 37 35 51 41 ...
$ 65 : num 13 50 63 55 15 29 20 16 64 48 ...
$ 66 : num 44 44 47 39 56 50 50 47 41 44 ...
$ 67 : num 39 61 36 40 45 27 34 33 37 22 ...
$ 75 : num 54 66 43 73 22 20 26 36 84 82 ...
$ 76 : num 46 47 39 44 21 21 14 22 24 24 ...
$ 78 : num NA 87 67 68 37 67 21 21 49 60 ...
$ 79 : num 41 50 60 76 53 59 83 45 46 78 ...
$ 80 : num 53 61 44 75 64 58 61 61 60 63 ...
$ 81 : num 53 78 64 85 45 55 50 57 30 36 ...
$ 82 : num 80 90 93 96 81 110 92 70 93 72 ...
$ 84 : num 57 59 51 72 67 59 74 57 72 78 ...
$ 86 : num 72 108 87 78 58 112 52 63 101 60 ...
$ 87 : num 37 64 55 64 70 32 62 41 64 82 ...
$ 88 : num 29 49 65 88 44 62 39 68 59 43 ...
- attr(*, "spec")=List of 2
..$ cols :List of 60
.. ..$ Mois : list()
.. .. ..- attr(*, "class")= chr "collector_character" "collector"
.. ..$ Citadine Tourcoing : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ Citadine Roubaix : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ Citadine Lille : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ MWR : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ COR : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ Citadine Armentières: list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ Citadine Halluin : list()
.. .. ..- attr(*, "class")= chr "collector_character" "collector"
.. ..$ L1 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ L2 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ L3 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ L4 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ L90 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ L91 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ Z1 : list()
.. .. ..- attr(*, "class")= chr "collector_character" "collector"
.. ..$ Z2 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ Z3 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ Z4 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 10 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 11 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 12 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 13 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 14 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 15 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 16 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 17 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 18 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 30 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 32 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 33 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 35 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 36 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 37 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 50 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 51 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 52 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 53 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 54 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 55 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 57 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 58 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 59 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 56 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 61 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 63 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 64 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 65 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 66 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 67 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 75 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 76 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 78 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 79 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 80 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 81 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 82 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 84 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 86 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 87 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
.. ..$ 88 : list()
.. .. ..- attr(*, "class")= chr "collector_number" "collector"
..$ default: list()
.. ..- attr(*, "class")= chr "collector_guess" "collector"
..- attr(*, "class")= chr "col_spec"
Pour consulter l’objet importé - dans ce cas un tableau de données - vous pouvez vous rendre dans la fenêtre en haut à droite de RStudio puis dans l’onglet “Environment”. Vous trouverez le tableau sous “Data”. En double-cliquant dessus, il s’ouvrira dans cette fenêtre et vous pourrez vérifier que le tableau a bien été importé.
Pour sauver un fichier au format csv, il faut utiliser la fonction write_csv
## write_csv(retards, "retards.csv")
readxl est un package qui permet d’importer (et d’exporter) des fichiers au format xls.
if (!require(readxl)) install.packages("readxl")
library(readxl)
Prenons un fichier au hasard de l’OFS : “Comportement de la population en matière de transport, chiffres clés - agglomération de Lausanne (définition 2000)”
Il est présent dans le dossier.
La fonction read_excel est ce qu’il nous faut.
aie <- read_excel("su-f-11.04.03-MZ-2015-A2_5586_Def2000.xls")
aie
Toutes les entrées sont considérées comme des chaînes de caractères.
str(aie)
Classes ‘tbl_df’, ‘tbl’ and 'data.frame': 39 obs. of 55 variables:
$ Comportement de la population en matière de transport, chiffres clés 2015 - agglomération de Lausanne (définition 2000): chr "Disponibilité d'une voiture, possession de permis et d'abonnement, taux de mobilité, distance journalière, durée moyenne des dé"| __truncated__ NA NA NA ...
$ X__1 : chr NA "Outils de transport" "Disponibilité d'une voiture" "[%]" ...
$ X__2 : chr NA NA NA "+/-" ...
$ X__3 : chr NA NA "Possession du permis de conduire" "[%]" ...
$ X__4 : chr NA NA NA "+/-" ...
$ X__5 : chr NA NA "Possession d'abonnements des TP" "[%]" ...
$ X__6 : chr NA NA NA "+/-" ...
$ X__7 : chr NA "Taux de mobilité" "Personnes mobiles le jour de référence (en déplacement)" "[%]" ...
$ X__8 : chr NA NA NA "+/-" ...
$ X__9 : chr NA "Distance journalière moyenne" "Total" "[km]" ...
$ X__10 : chr NA NA NA "+/-" ...
$ X__11 : chr NA NA "Mobilité douce" "[km]" ...
$ X__12 : chr NA NA NA "+/-" ...
$ X__13 : chr NA NA "Transport individuel motorisé" "[km]" ...
$ X__14 : chr NA NA NA "+/-" ...
$ X__15 : chr NA NA "Transports publics" "[km]" ...
$ X__16 : chr NA NA NA "+/-" ...
$ X__17 : chr NA NA "Travail" "[km]" ...
$ X__18 : chr NA NA NA "+/-" ...
$ X__19 : chr NA NA "Loisirs" "[km]" ...
$ X__20 : chr NA NA NA "+/-" ...
$ X__21 : chr NA "Durée moyenne des déplacements (sans les temps d'attente et de correspondance)" "Total" "[min.]" ...
$ X__22 : chr NA NA NA "+/-" ...
$ X__23 : chr NA NA "Mobilité douce" "[min.]" ...
$ X__24 : chr NA NA NA "+/-" ...
$ X__25 : chr NA NA "Transport individuel motorisé" "[min.]" ...
$ X__26 : chr NA NA NA "+/-" ...
$ X__27 : chr NA NA "Transports publics" "[min.]" ...
$ X__28 : chr NA NA NA "+/-" ...
$ X__29 : chr NA "Durée moyenne des déplacements (avec les temps d'attente et de correspondance)" "Total" "[min.]" ...
$ X__30 : chr NA NA NA "+/-" ...
$ X__31 : chr NA NA "Travail" "[min.]" ...
$ X__32 : chr NA NA NA "+/-" ...
$ X__33 : chr NA NA "Loisirs" "[min.]" ...
$ X__34 : chr NA NA NA "+/-" ...
$ X__35 : chr NA "Nombre d'étapes par jour" "Total" "[nombre]" ...
$ X__36 : chr NA NA NA "+/-" ...
$ X__37 : chr NA NA "Mobilité douce" "[nombre]" ...
$ X__38 : chr NA NA NA "+/-" ...
$ X__39 : chr NA NA "Transport individuel motorisé" "[nombre]" ...
$ X__40 : chr NA NA NA "+/-" ...
$ X__41 : chr NA NA "Transports publics" "[nombre]" ...
$ X__42 : chr NA NA NA "+/-" ...
$ X__43 : chr NA NA "Travail" "[nombre]" ...
$ X__44 : chr NA NA NA "+/-" ...
$ X__45 : chr NA NA "Loisirs" "[nombre]" ...
$ X__46 : chr NA NA NA "+/-" ...
$ X__47 : chr NA "Nombre de déplacements par jour" "Total" "[nombre]" ...
$ X__48 : chr NA NA NA "+/-" ...
$ X__49 : chr NA NA "Travail" "[nombre]" ...
$ X__50 : chr NA NA NA "+/-" ...
$ X__51 : chr NA NA "Loisirs" "[nombre]" ...
$ X__52 : chr NA NA NA "+/-" ...
$ X__53 : chr NA "Nombre de boucles par jour" "Total" "[nombre]" ...
$ X__54 : chr NA NA NA "+/-" ...
Le résultat n’est pas directement exploitable, et ce sera souvent le cas au moment de récupérer des fichiers publics, souvent structurés pour la lecture et pas pour une exploitation automatique.
Important : les fonctions utilisées traditionnellement pour importer des tableaux (par ex. read.table) importent par défaut les variables au format “factor”, un concept spécifique à R et aux langages prévus pour faire des statistiques. Ce format s’emploie principalement lorsqu’une variable est catégorielle ordinale, c’est-à-dire que les valeurs qu’elle peut prendre sont parmi un ensemble de “mots” (catégorielle) et qu’on peut les classer (ordinale), par exemple l’ensemble : “très mauvais”, “mauvais”, “bon”, “très bon”.
Pour obtenir ce résultat, il faut utiliser (quand elle est disponible) l’option stringsAsFactors = TRUE qui est généralement vraie («TRUE») par défaut.
Le même genre de technique peut être utilisé pour lire des fichiers aux formats suivants.
| but | fonction |
|---|---|
| pur texte | read_file, read_lines |
| png | readPNG |
| spss | package haven |
| json | package jsonlite |
| xml | package xml2 |
Les data frames sont un des formats les plus importants et les plus populaires de R.
Il s’agit d’un tableau de données, qu’il ne faut pas confondre avec les formats matrix et table.
Tous les éléments d’une matrice sont du même type.
m1 <- matrix(c(1, 2, 3, 4), ncol = 2)
m1
[,1] [,2]
[1,] 1 3
[2,] 2 4
Ici ce sont tous des nombres.
str(m1)
num [1:2, 1:2] 1 2 3 4
Mais si on glisse des lettres dans la liste…
m2 <- matrix(c(1, "b", "c", 4), ncol = 2)
m2
[,1] [,2]
[1,] "1" "c"
[2,] "b" "4"
Les éléments numériques sont devenus des chaînes de caractères.
str(m2)
chr [1:2, 1:2] "1" "b" "c" "4"
Il se passe quelque chose d’équivalent avec les vecteurs.
v1 <- c(1, 2, 3)
v1
[1] 1 2 3
v2 <- c(1, "b", 3)
v2
[1] "1" "b" "3"
En les comparant…
str(v1)
num [1:3] 1 2 3
str(v2)
chr [1:3] "1" "b" "3"
Le format table quand à lui est utilisé pour donner des tables de contingence.
Dans cet exemple, on tire 20 fois un dé 6.
dist <- round(runif(20, min = 1, max = 6))
dist
[1] 1 4 2 5 5 2 1 6 1 6 3 3 3 3 6 4 1 6 4 2
On regroupe les résultats les résultats.
table(dist)
dist
1 2 3 4 5 6
4 3 4 3 2 4
Un data frame est un tableau avec des observations en ligne et des variables en colonne. Les variables peuvent être de tout type (numériques, ordinales, catégorielles, dates, etc.).
On reprend le tableau de données des retards de bus vu précédemment.
Un aperçu rapide.
head(retards)
Comment accéder à une entrée (ligne).
retards[1,]
Comment accéder à une variable.
retards[,1] ## la première variable
De manière équivalente, si on a la connaissance de ladite variable.
retards$Mois
[1] "08. Aout" "09. Septembre" "10. Octobre" "11. Novembre" "03. Mars" "07. Juillet" "02. Février"
[8] "04. Avril" "05. Mai" "01. Janvier" "06. Juin"
Comment réarranger le tableau en fonction des mois de l’année ?
retards <- retards[order(retards$Mois),]
retards
La fonction order appliquée à retards$Mois permet de classer les mois dans l’ordre donné par les chaîne de caractère 01 à 11.
Ensuite, placé avant la virgule, order(retards$Mois) signifie que nous réarrangeons l’ordre des lignes du tableau. L’effet s’applique sur les lignes entières, et pas uniquement sur les cases de la colonne concernée.
Nous allons voir dans la prochaine partie comment faire des visualisations à partir d’un tableau de données.
Pour aller plus loin, un tutorial est disponible ici
http://www.cookbook-r.com/Manipulating_data/
Un autre ici
http://tutorials.iq.harvard.edu/R/Rgraphics/Rgraphics.html
et des exercices ici
https://www.datacamp.com/community/tutorials/15-easy-solutions-data-frame-problems-r
Pour apprendre à manipuler correctement un ou plusieurs tableaux de données, créer et transformer des variables, sélectionner des sous-ensembles, le package dplyr est chaudement recommandé.
https://cran.r-project.org/web/packages/dplyr/vignettes/dplyr.html
Une cheatsheet est également disponible.
https://github.com/rstudio/cheatsheets/raw/master/data-transformation.pdf
ggplot2 met en pratique la grammaire des graphiques, une théorie de Leland Wilkinson (1999).
http://www.springer.com/us/book/9780387245447
if (!require(ggplot2)) install.packages("ggplot2")
Loading required package: ggplot2
library(ggplot2)
if (!require(RColorBrewer)) install.packages("RColorBrewer")
Loading required package: RColorBrewer
library(RColorBrewer)
Nous utilisons un jeu de données interne à ggplot2 contenant le prix ainsi que d’autres attributs de 53 940 diamants.
Les commandes suivantes permettent de prendre connaissance du jeu de données.
## help(diamonds)
## View(diamonds)
head(diamonds)
str(diamonds)
Classes ‘tbl_df’, ‘tbl’ and 'data.frame': 53940 obs. of 10 variables:
$ carat : num 0.23 0.21 0.23 0.29 0.31 0.24 0.24 0.26 0.22 0.23 ...
$ cut : Ord.factor w/ 5 levels "Fair"<"Good"<..: 5 4 2 4 2 3 3 3 1 3 ...
$ color : Ord.factor w/ 7 levels "D"<"E"<"F"<"G"<..: 2 2 2 6 7 7 6 5 2 5 ...
$ clarity: Ord.factor w/ 8 levels "I1"<"SI2"<"SI1"<..: 2 3 5 4 2 6 7 3 4 5 ...
$ depth : num 61.5 59.8 56.9 62.4 63.3 62.8 62.3 61.9 65.1 59.4 ...
$ table : num 55 61 65 58 58 57 57 55 61 61 ...
$ price : int 326 326 327 334 335 336 336 337 337 338 ...
$ x : num 3.95 3.89 4.05 4.2 4.34 3.94 3.95 4.07 3.87 4 ...
$ y : num 3.98 3.84 4.07 4.23 4.35 3.96 3.98 4.11 3.78 4.05 ...
$ z : num 2.43 2.31 2.31 2.63 2.75 2.48 2.47 2.53 2.49 2.39 ...
On ne va pas garder l’entier du tableau de données, mais seulement un échantillon, afin de ne pas surcharger ce notebook.
diam <- diamonds[sample(1:nrow(diamonds), 1000),]
Remarque : à partir d’ici, nous parlons principalement de ggplot sans le “2” car il va s’agir de la fonction “ggplot”.
Le “2” n’est utilisé que dans le nom du package.
ggplot1 existe.
Attention ! L’input doit toujours être un data frame !
g <- ggplot(diam)
g
Contrairement à la fonction plot, qui bricole un visuel lorsqu’on entre la commande plot(diamonds), avec ggplot il ne se passe rien.
Juste un grand carré gris.
Le résultat avec le package base.
## plot(diamonds)
La commande de base plot(diamonds) considère toutes les variables du data frame et les croise entre elles - numériques comme ordinales - pour un résultat illisible et inutile.
Qu’obtient-on avec la commande ggplot ?
str(g)
List of 9
$ data :Classes ‘tbl_df’, ‘tbl’ and 'data.frame': 1000 obs. of 10 variables:
..$ carat : num [1:1000] 1.77 0.41 0.7 0.81 0.34 1 0.5 1.51 1.14 1 ...
..$ cut : Ord.factor w/ 5 levels "Fair"<"Good"<..: 3 2 5 1 5 5 4 3 3 3 ...
..$ color : Ord.factor w/ 7 levels "D"<"E"<"F"<"G"<..: 6 1 4 4 4 2 1 7 6 4 ...
..$ clarity: Ord.factor w/ 8 levels "I1"<"SI2"<"SI1"<..: 4 3 2 6 4 3 2 6 3 8 ...
..$ depth : num [1:1000] 60.2 63.8 61.2 64.8 62 62.3 58.5 60.6 63.5 58.3 ...
..$ table : num [1:1000] 58 56 56 56.2 54 55 60 58 56 62 ...
..$ price : int [1:1000] 13691 738 2270 3323 596 5396 1178 8789 4788 8002 ...
..$ x : num [1:1000] 7.88 4.68 5.73 5.82 4.47 6.41 5.21 7.36 6.62 6.51 ...
..$ y : num [1:1000] 7.83 4.72 5.78 5.98 4.5 6.34 5.19 7.4 6.58 6.57 ...
..$ z : num [1:1000] 4.73 3 3.52 3.82 2.78 3.97 3.04 4.47 4.19 3.81 ...
$ layers : list()
$ scales :Classes 'ScalesList', 'ggproto' <ggproto object: Class ScalesList>
add: function
clone: function
find: function
get_scales: function
has_scale: function
input: function
n: function
non_position_scales: function
scales: NULL
super: <ggproto object: Class ScalesList>
$ mapping : list()
$ theme : list()
$ coordinates:Classes 'CoordCartesian', 'Coord', 'ggproto' <ggproto object: Class CoordCartesian, Coord>
aspect: function
distance: function
expand: TRUE
is_linear: function
labels: function
limits: list
range: function
render_axis_h: function
render_axis_v: function
render_bg: function
render_fg: function
train: function
transform: function
super: <ggproto object: Class CoordCartesian, Coord>
$ facet :Classes 'FacetNull', 'Facet', 'ggproto' <ggproto object: Class FacetNull, Facet>
compute_layout: function
draw_back: function
draw_front: function
draw_labels: function
draw_panels: function
finish_data: function
init_scales: function
map: function
map_data: function
params: list
render_back: function
render_front: function
render_panels: function
setup_data: function
setup_params: function
shrink: TRUE
train: function
train_positions: function
train_scales: function
vars: function
super: <ggproto object: Class FacetNull, Facet>
$ plot_env :<environment: R_GlobalEnv>
$ labels : list()
- attr(*, "class")= chr [1:2] "gg" "ggplot"
On retrouve le data frame contenant nos données, ainsi que les différents éléments propres à l’approche grammaticale des graphiques proposée par ggplot2, pour l’instant vides :
layers
scales
mapping
theme
coordinates
facet
À ce stade, le graphe est vide car nous n’avons défini ni mapping ni géométries (voir figure suivante).
g <- ggplot(diam)
g
cf. figure suivante.
Pour rappel : ‘carat’ et ‘price’ sont des variables continues.
ggplot(diam, aes(x = carat, y = price))
On remarque que les échelles et les labels des axes sont déjà posés.
ggplot attend maintenant de savoir quoi dessiner.
Pas de figure…
ggplot(diam) + geom_point()
Error: geom_point requires the following missing aesthetics: x, y
Cette fois, ggplot n’a pas trouvé de mapping lui indiquant où poser son dessin, d’où l’erreur.
ggplot(diam, aes(x = carat, y = price)) + geom_point()
Pour comparaison, la commande la plus simple permettant d’obtenir (à peu près) le même résultat avec le package de base.
plot(diam$carat, diam$price)
Les échelles sont justes et les points sont bien situés, mais c’est tout et c’est moche.
C’est là le principe de ggplot : à partir de maintenant nous pouvons faire varier les éléments graphiques sans avoir à toucher aux données.
Par exemple, une interpolation.
ggplot(diam, aes(x = carat, y = price)) + geom_smooth()
Il suffit de les additionner pour les superposer.
Attention au ‘+’ à mettre à la fin de la ligne et pas au début.
ggplot(diam, aes(x = carat, y = price)) +
geom_point() +
geom_smooth()
Attention, l’ordre des géométries a une influence sur le graphique !
ggplot(diam, aes(x = carat, y = price)) +
geom_smooth() +
geom_point()
Dans le graphique précédent, la courbe d’interpolation a été dessinée avant les points.
Ainsi, elle apparaît dans la figure cachée sous ces derniers.
Le mapping peut se faire à plusieurs endroits :
Dans ggplot(), ce qui a pour effet d’appliquer le mapping à tous les autres éléments.
Dans les éléments graphiques eux-mêmes.
ggplot(diam, aes(x = carat, y = price)) + geom_point()
ggplot(diam, aes(x = carat)) + geom_point(aes(y = price))
ggplot(diam) + geom_point(aes(x = carat, y = price))
Bref, on peut mapper de nombreuses variables, en une seule fois, directement dans ggplot et elles seront reprises par les autres éléments.
Par exemple, l’attribut color de geom_point.
Remarque : la variable ‘clarity’ est ordinale.
ggplot(diam, aes(x = carat, y = price, color = clarity)) +
geom_point()
Grâce à ce seul mapping, ggplot attribue à chaque modalité une couleur, attribue aux points la couleur correspondante, et génère dans la foulée une légende (une des angoisses lorsqu’on travaille avec les commandes de base).
Pour l’anecdote, nous aurions obtenu le même résultat en faisant le mapping dans geom_point.
ggplot(diam, aes(x = carat, y = price)) +
geom_point(aes(color = clarity))
Attention à ne pas oublier de faire le mapping, c’est-à-dire d’utiliser la fonction aes(), sinon ça ne fonctionnera pas !
ggplot(diam, aes(x = carat, y = price)) +
geom_point(color = clarity)
Error in layer(data = data, mapping = mapping, stat = stat, geom = GeomPoint, :
object 'clarity' not found
On trouve toutes les géométries disponibles ainsi que de nombreuses autres ressources indispensables dans l’indispensable cheat sheet de ggplot2 !
C’est hasardeux, mais on peut également appliquer une transformation continue (size) à une variable ordinale (cut).
ggplot(diam, aes(x = carat, y = price, color = clarity, size = cut)) +
geom_point()
Toutefois, il est recommandé d’appliquer une transformation continue (size) à une variable continue (par exemple depth) et une transformation discrète comme la couleur ou la forme (shape) à une variable discrète (par exemple cut).
ggplot(diam, aes(x = carat, y = price, color = clarity, shape = cut)) +
geom_point()
Détail qui a son importance dans l’exemple suivant : la fonction geom_smooth va hériter du mapping sur la couleur.
Note : “se = FALSE” empêche l’affichage de l’incertitude.
ggplot(diam, aes(x = carat, y = price, color = clarity)) +
geom_point() +
geom_smooth(se = FALSE)
Pour le mapping sur la forme (au lieu de la couleur), on repassera.
ggplot(diam, aes(x = carat, y = price, shape = cut)) +
geom_point() +
geom_smooth(se = FALSE)
Et si l’on prend en considération les deux en même temps, ça peut mener à la catastrophe.
ggplot(diam, aes(x = carat, y = price, color = clarity, shape = cut)) +
geom_point() +
geom_smooth(se = FALSE)
Le même code que précédemment, avec cette fois le graphique à la place du message d’erreur.
ggplot(diam, aes(x = carat, y = price, color = clarity, shape = cut)) +
geom_point() + geom_smooth(se = FALSE)
Il est nécessaire de redistribuer le mapping plus subtilement.
ggplot(diam, aes(x = carat, y = price, color = clarity)) +
geom_point(aes(shape = cut)) +
geom_smooth(se = FALSE)
D’autres exemples concernant les attributs des éléments géométriques.
ggplot(diam, aes(x = carat, y = price, color = clarity, size = depth)) +
geom_point()
Il est possible évidemment de modifier plus subtilement la taille des sommets lorsqu’on fait un mapping dessus, si les valeurs par défaut ne nous plaisent pas.
En général, cela passe par les fonctions scale.
Elles commencent par scale_ (voir la cheat sheet).
Nous reviendrons plus en détail là-dessus.
Dans la figure suivante, nous donnons des valeurs minimales et maximales pour la taille des sommets.
ggplot(diam, aes(x = carat, y = price, color = clarity, size = depth)) +
geom_point() +
scale_size(range = c(1,3))
Remarque : l’effet est difficile à observer car la variance est très petite.
summary(diam$depth)
Min. 1st Qu. Median Mean 3rd Qu. Max.
55.90 61.10 61.90 61.79 62.50 68.40
sd(diam$depth)
[1] 1.410995
Au passage, remarquons que l’on peut aussi utiliser l’attribut size de geom_point sans mapping.
ggplot(diam, aes(x = carat, y = price, color = clarity)) +
geom_point(size = 1)
Dans ce cas, la taille des points est considérée hors mapping et donc indépendamment d’une quelconque variable.
Remarquons également l’organisation hiérarchique des mappings et des transformations : dans l’exemple qui suit, la variable depth est tout d’abord mappée sur la taille des sommets.
Puis, dans geom_point, on lui attribue une valeur fixe.
Arrivée ensuite, c’est cette dernière qui l’emporte sur le mapping initial.
ggplot(diam, aes(x = carat, y = price, color = clarity, size = depth)) +
geom_point(size = 1)
Au passage, la modification du titre en légende dépend de la fonction scale correspondante (ici scale_size).
C’est logique, mais contre-intuitif pour qui aura passé beaucoup (trop ?) de temps avec les commandes graphiques de base dans R.
ggplot(diam, aes(x = carat, y = price, color = clarity, size = depth)) +
geom_point() +
scale_size("DEPTH", range = c(1,3))
Nous avons vu comment :
Charger les données.
Faire un mapping.
Superposer une ou plusieurs géométries.
Il nous reste à découvrir :
Le facettage.
Les échelles.
Les annotations.
Les types de graphiques autres que les scatterplots.
Comment sauver un graphique.
Comment bien préparer ses données.
Attention ! Ceci s’applique à des variables discrètes.
Le facettage divise le jeu de données en fonction des catégories d’une variable.
Dans un sens…
ggplot(diam, aes(x = carat, y = price)) +
geom_point() +
facet_grid(. ~ cut)
… et dans l’autre.
(Remarquez la position inversée de la variable cut dans facet_grid().)
ggplot(diam, aes(x = carat, y = price)) +
geom_point() +
facet_grid(cut ~ .)
En croisant deux variables discrètes.
ggplot(diam, aes(x = carat, y = price)) +
geom_point() +
facet_grid(color ~ clarity)
Finalement, en croisant deux variables discrètes, avec un mapping sur la couleur.
ggplot(diam, aes(x = carat, y = price, color = cut)) +
geom_point() +
facet_grid(color ~ clarity)
Il y a une autre option de facettage lorsqu’on n’utilise qu’une seule variable discrète : facet_wrap.
Dans ce cas, remarquez que nous n’utilisons plus le point (.) avant le tilde (~).
ggplot(diam, aes(x = carat, y = price)) +
geom_point() +
facet_wrap(~ clarity)
Elles commencent toutes par scale_
Ensuite, on complète avec le nom de la variable concernée.
scale_alpha scale_alpha_continuous scale_alpha_discrete scale_alpha_identity scale_alpha_manual scale_color_brewer scale_color_continuous scale_color_discrete scale_color_distiller scale_color_gradient scale_color_gradient2 scale_color_gradientn scale_color_grey scale_color_hue scale_color_identity scale_color_manual scale_colour_brewer scale_colour_continuous scale_colour_date scale_colour_datetime scale_colour_discrete scale_colour_distiller scale_colour_gradient scale_colour_gradient2 scale_colour_gradientn scale_colour_grey scale_colour_hue scale_colour_identity scale_colour_manual scale_continuous scale_date scale_fill_brewer scale_fill_continuous scale_fill_date scale_fill_datetime scale_fill_discrete scale_fill_distiller scale_fill_gradient scale_fill_gradient2 scale_fill_gradientn scale_fill_grey scale_fill_hue scale_fill_identity scale_fill_manual scale_identity scale_linetype scale_linetype_continuous scale_linetype_discrete scale_linetype_identity scale_linetype_manual scale_manual scale_radius scale_shape scale_shape_continuous scale_shape_discrete scale_shape_identity scale_shape_manual scale_size scale_size_area scale_size_continuous scale_size_date scale_size_datetime scale_size_discrete scale_size_identity scale_size_manual scale_x_continuous scale_x_date scale_x_datetime scale_x_discrete scale_x_log10 scale_x_reverse scale_x_sqrt scale_y_continuous scale_y_date scale_y_datetime scale_y_discrete scale_y_log10 scale_y_reverse scale_y_sqrt
Par exemple, si l’on travaille sur la couleur, on pourra faire varier la palette des couleurs en modifiant le nom de l’échelle. Faites le test en écrivant scale_color_ dans la console puis en pressant sur la touche tab pour voir les suggestions…
En gris
ggplot(diam, aes(x = carat, y = price, color = clarity)) +
geom_point() +
scale_color_grey()
La version par défaut.
ggplot(diam, aes(x = carat, y = price, color = clarity)) +
geom_point() +
scale_color_discrete()
ColorBrewer, nommée d’après une de ses auteurs, Cnythia Brewer, est une librairie de couleurs précalculées qui s’accordent bien.
On peut les utiliser ici avec la fonction scale_color_brewer.
ggplot(diam, aes(x = carat, y = price, color = clarity)) +
geom_point() +
scale_color_brewer()
En changeant de palette.
ggplot(diam, aes(x = carat, y = price, color = clarity)) +
geom_point() +
scale_color_brewer(palette = 2)
Attention si vous utilisez la mauvaise échelle : soit il ne se passera rien (comme dans la figure suivante), soit il y aura un message d’erreur.
ggplot(diam, aes(x = carat, y = price, color = clarity)) +
geom_point() +
scale_fill_brewer(palette = 2)
Dans la figure suivante, nous changeons la forme utilisée pour dessiner les points afin qu’il y ait un pourtour (color) et un contenu (fill).
Cette transformation a été effectuée en donnant comme instruction que les points doivent changer de forme (indépendamment de toute variable).
Nous en profitons pour dessiner l’intérieur. Quelle fonction faut-il utiliser ?
ggplot(diam, aes(x = carat, y = price, fill = clarity)) +
geom_point(shape = 21) +
scale_fill_brewer(palette = 2)
Mais les échelles, ça ne concerne pas seulement l’intérieur du graphique.
Nous utilisons également des échelles sur les axes.
ggplot(diam, aes(x = carat, y = price, color = clarity)) +
geom_point() +
scale_x_continuous(breaks = c(1,3), minor_breaks = c(sqrt(2), pi)) +
scale_y_continuous(breaks = sample(20000, 10))
Échelle logarithmique FTW.
ggplot(diam, aes(x = carat, y = price, color = clarity)) +
geom_point() +
scale_y_log10()
Via un mapping, par exemple pour un MDS.
ggplot(diam, aes(x = carat, y = price, label = clarity)) +
geom_text()
L’annotation manuelle est possible, à l’ancienne, mais pas forcément recommandée.
ggplot(diam, aes(x = carat, y = price, color = clarity)) +
geom_point() +
annotate("text", x = 3.5, y = 10000, label = "HELLO")
C’est la seule fois que nous voyons une transformation statistique dans cette présentation (malheureusement).
Ce sont les fonctions commençant par stat_.
Pour plus d’infos, voir la cheat sheet.
ggplot(diam, aes(price)) +
geom_area(stat = "bin")
ggplot(diam, aes(price)) +
geom_density(kernel = "gaussian")
ggplot(diam, aes(price)) +
geom_histogram(binwidth = 30)
Avec une variable discrète, cette fois.
ggplot(diam, aes(color)) +
geom_bar()
Une variable discrète et une variable continue.
ggplot(diam, aes(x = color, y = price)) +
geom_boxplot()
Deux variables discrètes.
ggplot(diam, aes(x = cut, y = color)) +
geom_count()
ggplot(diamonds, aes(x=price, fill=cut)) +
geom_histogram()
Distributions bi-variées.
ggplot(diamonds, aes(carat, price)) +
geom_bin2d(binwidth = c(0.25, 500))
ggplot(diamonds, aes(carat, price)) +
geom_hex()
La fonction ggtitle est utilisée pour choisir un titre.
ggplot(diam, aes(x = carat, y = price, color = clarity)) +
geom_point() +
ggtitle("Mon joli graphique")
Et, classique pour une fois, xlab et ylab pour changer les noms des axes.
ggplot(diam, aes(x = carat, y = price, color = clarity)) +
geom_point() +
xlab("Ma jolie abscisse") +
ylab("Ma jolie ordonnée")
Pour varier les thèmes : theme_.
ggplot(diam, aes(x = carat, y = price, color = clarity)) +
geom_point() +
theme_bw()
ggplot(diam, aes(x = carat, y = price, color = clarity)) +
geom_point() +
theme_dark()
ggplot(diam, aes(x = carat, y = price, color = clarity)) +
geom_point() +
theme_minimal()
ggsave
function (filename, plot = last_plot(), device = NULL, path = NULL,
scale = 1, width = NA, height = NA, units = c("in", "cm",
"mm"), dpi = 300, limitsize = TRUE, ...)
{
dev <- plot_dev(device, filename, dpi = dpi)
dim <- plot_dim(c(width, height), scale = scale, units = units,
limitsize = limitsize)
if (!is.null(path)) {
filename <- file.path(path, filename)
}
dev(file = filename, width = dim[1], height = dim[2], ...)
on.exit(utils::capture.output(grDevices::dev.off()))
grid.draw(plot)
invisible()
}
<environment: namespace:ggplot2>
Par exemple
ggsave("plot.pdf", width = 7, height = 7)
«Tidy data is a standard way of mapping the meaning of a dataset to its structure.»
«A dataset is messy or tidy depending on how rows, columns and tables are matched up with observations, variables and types.»
«In tidy data:
Source :
# library(tidyr)
# vignette("tidy-data")
Marie-Louise Timcke a proposé sur journocode.com une très bonne ressource à ce sujet.
En particulier, elle présente l’exemple suivant, extrait d’explications d’Hadley Wickham.
Le format tidy, ou long form, est fortement recommandé dans ggplot2.
Comment fonctionnent les notebooks ?
Ce document que vous avez ouvert dans RStudio ou dans un navigateur web est un notebook.
C’est un format de document permettant de présenter du texte, du code, et les résultats de l’exécution du code.
Dans la recherche scientifique, ce format permet de répliquer une expérience.
La démarche de partager un notebook en même temps qu’un article scientifique devrait à l’avenir devenir un standard.
Le système de notebooks le plus répandu est Jupyter, qui fonctionne avec les langages de programmation Julia, Python et R, mais permet aussi de gérer d’autres langages de programmation.
Ici, nous utilisons des notebooks au format prévu par RStudio.
Un notebook peut se décliner en plusieurs formats.
.Rmds’ouvre dans RStudio..nb.htmls’ouvre dans un navigateur..htmlcontient les slides (dans le cas présent).Le code apparaît systématiquement dans une case sur fond gris.
Le résultat du code apparaît ensuite dans une case sur fond blanc ou gris selon les réglages.
En ouvrant le notebook dans RStudio, vous aurez la possibilité de modifier le code et de le réexécuter.
Par exemple, dans le code ci-dessous, nous sauvons la valeur “2” dans la variable “a” et la valeur “e” dans la variable “b”. Puis nous élevons a à la puissance b, c’est-à-dire 2 à la puissance 3.
Le résultat s’affiche en-dessous.